package qc.module.ehs.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.enums.EhsTaskDestObjectTypeEnum;
import qc.common.core.enums.EhsTaskGroupObjectTypeEnum;
import qc.common.core.exception.QCPromptException;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.common.core.utils.DateUtil;
import qc.common.core.utils.IdentifierUtil;
import qc.module.ehs.dto.task.*;
import qc.module.ehs.dto.taskgroup.TaskGroupAddDto;
import qc.module.ehs.dto.taskgroup.TaskGroupInfoDto;
import qc.module.ehs.dto.taskgroup.TaskGroupUpdateDto;
import qc.module.ehs.dto.taskitem.TaskItemInfoDto;
import qc.module.ehs.entity.EhsTaskGroup;
import qc.module.ehs.entity.EhsTaskInfo;
import qc.module.ehs.mapper.EhsTaskGroupMapper;
import qc.module.ehs.repository.EhsTaskGroupRepository;
import qc.module.ehs.repository.EhsTaskInfoRepository;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;

/**
 * 安全任务分组service
 *
 * @author QuCheng Tech
 * @since 2024/11/13
 */
@Service
public class EhsTaskGroupService {

    @Autowired
    private EhsTaskGroupRepository repository;

    @Autowired
    private EhsTaskInfoRepository taskInfoRepository;

    @Autowired
    private EhsTaskItemService taskItemService;

    /**
     * 获取指定任务的所有分组信息
     *
     * @param taskId 任务ID
     * @return List<TaskGroupInfoDto>
     * @author QuCheng Tech
     * @since 2024/11/14
     */
    public List<TaskGroupInfoDto> getTaskGroups(String taskId) {

        //同一个任务中的任务分组均按照分组排序号升序、分组名称升序；
        LambdaQueryWrapper<EhsTaskGroup> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsTaskGroup::getTaskid, taskId)
                .orderByAsc(EhsTaskGroup::getOdr, EhsTaskGroup::getGroupname);
        List<EhsTaskGroup> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return EhsTaskGroupMapper.MAPPER.toDtoList(ens);
        }
        return null;
    }

    /**
     * 获取指定任务分组信息
     *
     * @param id 任务分组ID
     * @return TaskGroupInfoDto
     * @author QuCheng Tech
     * @since 2024/11/14
     */
    public TaskGroupInfoDto getGroup(String id) {

        EhsTaskGroup en = repository.selectById(id);
        if (Objects.nonNull(en)) {
            return EhsTaskGroupMapper.MAPPER.toDto(en);
        }
        return null;
    }

    /**
     * 新增任务分组
     * <p>
     * 不管任务是否派单均能进行该操作，要求任务的执行完成为false并且终止/取消为false；
     * 该操作不影响已执行的分组和任务项；新增时如有指定分组对象（单元、设备设施、危险源）需要判断是否已有，已有对象不重复添加；如未指定分组对象，不需要进行重复判断；
     * <p>
     * 2024/11/18修改：任务未派单才能进行该操作。
     *
     * @param addDto 新增对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/14
     */
    public String add(TaskGroupAddDto addDto) {
        if (addDto == null) return QCUnifyReturnValue.Warn("请求对象不能为空");
        if (StringUtils.isBlank(addDto.getTaskid()))
            return QCUnifyReturnValue.Warn("任务ID不能为空");
        if (StringUtils.isBlank(addDto.getGroupname()))
            return QCUnifyReturnValue.Warn("任务分组名称不能为空");

        EhsTaskInfo taskInfo = taskInfoRepository.selectById(addDto.getTaskid());
        if (Objects.isNull(taskInfo)) return QCUnifyReturnValue.Warn("指定任务信息不存在");

        //判断未派单才能进行操作
        if (taskInfo.getHasdispatch()) return QCUnifyReturnValue.Warn("任务已派单，无法新增任务分组");

        //判断任务的状态：要求任务的执行完成为false并且终止/取消为false；
        if (taskInfo.getHasfinish() || taskInfo.getHasend())
            return QCUnifyReturnValue.Warn("指定任务已经执行完成或者已经终止/取消，无法进行新增分组操作。");

        //addDto转换为entity，设置属性默认值
        EhsTaskGroup en = EhsTaskGroupMapper.MAPPER.toEntity(addDto);
        en.setGroupid(IdentifierUtil.randomUUID());
        en.setHasfinish(false);
        en.setHasend(false);
        en.setExeccount(0x0);
        en.setExecidentifycount(0x0);
        en.setExectroublecount(0x0);

        //获取指定任务的所有分组
        List<TaskGroupInfoDto> taskGroups = getTaskGroups(addDto.getTaskid());

        if (CollectionUtils.isNotEmpty(taskGroups)) {
            //如有指定分组对象（单元、设备设施、危险源）需要判断是否已有，已有对象不重复添加；如未指定分组对象，不需要进行重复判断；
            if (StringUtils.isBlank(addDto.getUnitid()) && StringUtils.isBlank(addDto.getFacilityid()) &&
                    StringUtils.isBlank(addDto.getHazardid())) {
                //未指定分组对象，不需要进行重复判断；新增分组
                if (repository.insert(en) < 0x1) {
                    return QCUnifyReturnValue.Warn("新增任务分组失败");
                }
            } else {
                //有指定分组对象（单元、设备设施、危险源）需要判断是否已有，已有对象不重复添加；
                if (StringUtils.isNotBlank(addDto.getUnitid())) {
                    TaskGroupInfoDto group = taskGroups.stream().filter(p ->
                            p.getUnitid().equals(addDto.getUnitid())).findAny().orElse(null);
                    if (group == null) {
                        //新增分组
                        if (repository.insert(en) < 0x1) {
                            return QCUnifyReturnValue.Warn("新增任务分组失败");
                        }
                    }
                }
                if (StringUtils.isNotBlank(addDto.getFacilityid())) {
                    TaskGroupInfoDto group = taskGroups.stream().filter(p ->
                            p.getFacilityid().equals(addDto.getFacilityid())).findAny().orElse(null);
                    if (group == null) {
                        //新增分组
                        if (repository.insert(en) < 0x1) {
                            return QCUnifyReturnValue.Warn("新增任务分组失败");
                        }
                    }
                }
                if (StringUtils.isNotBlank(addDto.getHazardid())) {
                    TaskGroupInfoDto group = taskGroups.stream().filter(p ->
                            p.getHazardid().equals(addDto.getHazardid())).findAny().orElse(null);
                    if (group == null) {
                        //新增分组
                        if (repository.insert(en) < 0x1) {
                            return QCUnifyReturnValue.Warn("新增任务分组失败");
                        }
                    }
                }
            }
        } else {
            //新增分组
            if (repository.insert(en) < 0x1) {
                return QCUnifyReturnValue.Warn("新增任务分组失败");
            }
        }

        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改任务分组
     * <p>
     * 不管任务是否派单均能进行该操作，要求任务的执行完成为false并且终止/取消为false；同时要求分组的执行完成为false并且终止/取消为false；
     * 该操作不影响已执行的分组和任务项；
     * 修改时不对分组中的关联对象信息进行修改，如果指定的关联对象错误需要进行删除或对指定分组进行终止/取消操作；
     * 新增时如有指定分组对象（单元、设备设施、危险源）需要判断是否已有，已有对象不重复添加；如未指定分组对象，不需要进行重复判断；
     * <p>
     * 2024/11/18修改：任务未派单才能进行该操作。
     *
     * @param updateDto 修改对象DTO
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/15
     */
    public String update(TaskGroupUpdateDto updateDto) {
        if (updateDto == null) return QCUnifyReturnValue.Warn("请求对象不能为空");
        if (StringUtils.isBlank(updateDto.getGroupid()))
            return QCUnifyReturnValue.Warn("分组ID不能为空");
        if (StringUtils.isBlank(updateDto.getGroupname()))
            return QCUnifyReturnValue.Warn("任务分组名称不能为空");

        //获取指定分组
        EhsTaskGroup group = repository.selectById(updateDto.getGroupid());
        if (Objects.isNull(group)) return QCUnifyReturnValue.Warn("指定分组信息不存在。");

        //获取指定分组的任务信息
        EhsTaskInfo taskInfo = taskInfoRepository.selectById(group.getTaskid());

        //判断未派单才能进行操作
        if (taskInfo.getHasdispatch()) return QCUnifyReturnValue.Warn("任务已派单，无法修改任务分组");

        //判断任务和分组的状态：要求任务的执行完成为false并且终止/取消为false；同时要求分组的执行完成为false并且终止/取消为false；
        if (taskInfo.getHasfinish() || taskInfo.getHasend())
            return QCUnifyReturnValue.Warn("指定任务已经执行完成或者已经终止/取消，无法再进行修改分组操作。");
        if (group.getHasfinish() || group.getHasend())
            return QCUnifyReturnValue.Warn("指定分组已经执行完成或者已经终止/取消，无法再进行修改分组操作。");

        //修改分组信息
        if (updateDto.getResdeptid() != null && updateDto.getResdeptid() > 0x0) {
            group.setResdeptid(updateDto.getResdeptid());
            group.setResdeptname(updateDto.getResdeptname());
        }
        if (updateDto.getResuserid1() != null && updateDto.getResuserid1() > 0x0) {
            group.setResuserid1(updateDto.getResuserid1());
            group.setResusername1(updateDto.getResusername1());
        }
        if (updateDto.getResuserid2() != null && updateDto.getResuserid2() > 0x0) {
            group.setResuserid2(updateDto.getResuserid2());
            group.setResusername2(updateDto.getResusername2());
        }
        repository.updateById(group);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 删除任务分组
     * <p>
     * 要求任务的派单状态为false，已经派单的任务分组不能删除，只能进行终止/取消；
     * 删除分组时不需要去判断或删除任务项，因为在未派单时不生成任务项记录；
     *
     * @param id 任务分组ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/15
     */
    public String delete(String id) {

        //获取指定分组
        EhsTaskGroup group = repository.selectById(id);

        if (Objects.nonNull(group)) {
            //获取指定分组的任务信息
            EhsTaskInfo taskInfo = taskInfoRepository.selectById(group.getTaskid());

            //判断任务的派单状态
            if (taskInfo.getHasdispatch()) {
                //任务已派单，设置分组为终止/取消
                group.setHasend(true);
                repository.updateById(group);
            } else {
                //任务未派单，删除分组
                repository.deleteById(id);
            }
        }

        return QCUnifyReturnValue.Success();
    }

    /**
     * 设置指定任务分组状态为完成
     * <p>
     * 要求任务分组的执行完成为false并且终止/取消为false；还需要判断该分组的任务项执行完成为true或终止/取消为true，即要求分组中的每个任务项都是完成或终止/取消状态；
     * 同时对任务的所有分组状态进行判断，如果任务的所有分组的执行完成为true或终止/取消为true设置任务的执行完成为true；
     *
     * @param id 任务分组ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/15
     */
    public String finish(String id) {

        //获取指定任务分组
        EhsTaskGroup group = repository.selectById(id);
        if (Objects.isNull(group)) return null;

        //判断任务分组状态：执行完成为false并且终止/取消为false
        if (!group.getHasfinish() && !group.getHasend()) {

            //还需要判断该分组的任务项执行完成为true或终止/取消为true，即要求分组中的每个任务项都是完成或终止/取消状态；
            //获取指定分组的所有任务项
            List<TaskItemInfoDto> items = taskItemService.getItemsByGroupId(id);
            if (CollectionUtils.isNotEmpty(items)) {
                //存在任务项没有完成也没有终止则提示
                List<TaskItemInfoDto> notEndItems = items.stream().filter(p ->
                        p.isHasfinish() == false && p.isHasend() == false).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(notEndItems))
                    return QCUnifyReturnValue.Warn("指定任务分组存在未完成或者未终止的任务项，无法进行完成操作。");
            }

            //修改任务分组状态为已完成
            group.setHasfinish(true);
            repository.updateById(group);

            //对任务的所有分组状态进行判断，如果任务的所有分组的执行完成为true或终止/取消为true设置任务的执行完成为true；
            //获取指定任务的所有分组
            List<TaskGroupInfoDto> taskGroups = getTaskGroups(group.getTaskid());
            if (CollectionUtils.isNotEmpty(taskGroups)) {
                List<TaskGroupInfoDto> notEndGroups = taskGroups.stream().filter(p ->
                        p.isHasfinish() == false && p.isHasend() == false).collect(Collectors.toList());
                if (CollectionUtils.isEmpty(notEndGroups)) {
                    //设置任务为执行完成
                    EhsTaskInfo taskInfo = taskInfoRepository.selectById(group.getTaskid());
                    taskInfo.setHasfinish(true);
                    taskInfoRepository.updateById(taskInfo);
                }
            }
        }

        return QCUnifyReturnValue.Success();
    }

    /**
     * 设置指定任务分组状态为终止
     * <p>
     * 要求任务分组的执行完成为false并且终止/取消为false；
     * 终止时需同时设置分组和分组下未完成未终止的任务项为终止状态；
     *
     * @param id 任务分组ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/15
     */
    public String end(String id) {

        //获取指定任务分组
        EhsTaskGroup group = repository.selectById(id);
        if (Objects.isNull(group)) return null;

        //判断任务分组状态：执行完成为false并且终止/取消为false
        if (!group.getHasfinish() && !group.getHasend()) {

            //终止时需同时设置分组和分组下未完成未终止的任务项为终止状态；
            //获取指定分组的所有任务项
            List<TaskItemInfoDto> items = taskItemService.getItemsByGroupId(id);
            if (CollectionUtils.isNotEmpty(items)) {
                //存在任务项没有完成也没有终止，设置任务项为终止
                List<TaskItemInfoDto> notEndItems = items.stream().filter(p ->
                        p.isHasfinish() == false && p.isHasend() == false).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(notEndItems)) {
                    List<String> itemIds = notEndItems.stream().map(TaskItemInfoDto::getItemid).collect(Collectors.toList());
                    for (String itemId : itemIds) {
                        taskItemService.end(itemId);
                    }
                }

            }

            //设置任务分组为终止
            group.setHasend(true);
            repository.updateById(group);
        }

        return QCUnifyReturnValue.Success();
    }

    /**
     * 设置指定任务分组状态为继续
     * <p>
     * 要求任务分组的终止/取消为true；
     * 继续时需同时设置分组和分组下已终止的任务项终止/取消为false；
     *
     * @param id 任务分组ID
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/15
     */
    public String setContinue(String id) {

        //获取指定任务分组
        EhsTaskGroup group = repository.selectById(id);
        if (Objects.isNull(group)) return null;

        //要求任务分组的终止/取消为true；
        if (group.getHasend()) {
            //继续时需同时设置分组和分组下已终止的任务项终止/取消为false； 
            //获取指定分组的所有任务项
            List<TaskItemInfoDto> items = taskItemService.getItemsByGroupId(id);
            if (CollectionUtils.isNotEmpty(items)) {
                List<TaskItemInfoDto> isEndItems = items.stream().filter(p -> p.isHasend()==true).collect(Collectors.toList());
                if (CollectionUtils.isNotEmpty(isEndItems)) {
                    List<String> itemIds = isEndItems.stream().map(TaskItemInfoDto::getItemid).collect(Collectors.toList());
                    for (String itemId : itemIds) {
                        taskItemService.setContinue(itemId);
                    }
                }
            }

            //设置分组终止/取消位false
            group.setHasend(false);
            repository.updateById(group);
        }
        return QCUnifyReturnValue.Success();
    }

    /**
     * 批量删除任务分组
     *
     * @param ids 任务分组ID集合
     * @return 成功返回null，失败返回错误或提示信息
     * @author QuCheng Tech
     * @since 2024/11/14
     */
    public String deleteByIds(List<String> ids) {
        repository.deleteBatchIds(ids);
        return QCUnifyReturnValue.Success();
    }

    /**
     * 获取指定任务关联的分组对象类型的对象id集合
     *
     * @param taskId       任务ID
     * @param groupobjtype 任务关联的分组对象类型
     * @return 任务关联的分组对象ID集合
     * @author QuCheng Tech
     * @since 2024/11/14
     */
    public List<String> getObjectIds(String taskId, EhsTaskGroupObjectTypeEnum groupobjtype) {

        List<String> result = new ArrayList<>();

        LambdaQueryWrapper<EhsTaskGroup> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(EhsTaskGroup::getTaskid, taskId)
                .eq(EhsTaskGroup::getHasend, false);//查询未终止/取消的分组
        List<EhsTaskGroup> ens = repository.selectList(wrapper);

        if (CollectionUtils.isNotEmpty(ens)) {
            if (groupobjtype == EhsTaskGroupObjectTypeEnum.UNIT) {
                result = ens.stream().map(EhsTaskGroup::getUnitid).collect(Collectors.toList());
            } else if (groupobjtype == EhsTaskGroupObjectTypeEnum.TROUBLE) {
                result = ens.stream().map(EhsTaskGroup::getHazardid).collect(Collectors.toList());
            } else {
                //其他默认为任务分组对象类型为自定义，不处理
            }
        }
        return result;
    }

    /**
     * 删除指定任务关联对象类型的对象：修改是否终止/取消的状态为true
     * 删除原有：在分组中对本次删除的分组设置终止/取消为true，同时对任务项中设置终止/取消为true；
     *
     * @param taskId
     * @param objIds
     * @param objectType
     * @return
     */
    //public String update(String taskId,List<String> objIds,Integer objectType){
    //
    //    LambdaQueryWrapper<EhsTaskGroup> wrapper = new LambdaQueryWrapper<>();
    //    wrapper.eq(EhsTaskGroup::getTaskid,taskId);
    //    if (objectType == EhsTaskRelateObjectTypeEnum.UNIT.getIndex()){
    //        wrapper.in(EhsTaskGroup::getUnitid,objIds);
    //    }else if (objectType == EhsTaskRelateObjectTypeEnum.FACILITY.getIndex()){
    //        wrapper.in(EhsTaskGroup::getFacilityid,objIds);
    //    }else if (objectType == EhsTaskRelateObjectTypeEnum.HAZARD.getIndex()){
    //        wrapper.in(EhsTaskGroup::getHazardid,objIds);
    //    }else if (objectType == EhsTaskRelateObjectTypeEnum.FIRST_TYPE_HAZARD.getIndex()){
    //
    //    }else if (objectType == EhsTaskRelateObjectTypeEnum.SECOND_TYPE_HAZARD.getIndex()){
    //
    //    }else {
    //
    //    }
    //    List<EhsTaskGroup> ens = repository.selectList(wrapper);
    //    if (CollectionUtils.isNotEmpty(ens)){
    //        List<String> groupIds = ens.stream().map(EhsTaskGroup::getGroupid).collect(Collectors.toList());
    //        
    //        //获取指定任务、指定任务分组的任务项集合，设置终止/取消为true；
    //        List<TaskItemInfoDto> items = taskItemService.getItemsByTaskIdAndGroupIds(taskId,groupIds);
    //        if (CollectionUtils.isNotEmpty(items)){
    //            
    //        }
    //    }
    //    
    //}

    /**
     * 获取指定责任部门的任务ID集合
     *
     * @param deptId 责任部门ID
     * @return 任务ID集合
     * @author QuCheng Tech
     * @since 2024/11/18
     */
    public List<String> getTaskIdByDeptId(Integer deptId) {
        LambdaQueryWrapper<EhsTaskGroup> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(EhsTaskGroup::getTaskid)
                .eq(EhsTaskGroup::getResdeptid, deptId);
        List<EhsTaskGroup> ens = repository.selectList(wrapper);
        if (CollectionUtils.isNotEmpty(ens)) {
            return ens.stream().map(EhsTaskGroup::getTaskid).collect(Collectors.toList());
        }
        return null;
    }

    /**
     * 查询指定任务的执行情况一览表
     * <p>
     * 分组为行，执行周期为列，表格方式显示每个分组每个周期的执行情况；
     * 最后增加一列显示汇总信息，汇总按分组显示完成周期数、超时次数等；
     *
     * @param taskId 任务ID
     * @return TaskScheduleDto
     * @author QuCheng Tech
     * @since 2024/11/18
     */
    public TaskScheduleDto getTaskSchedule(String taskId) throws QCPromptException {

        TaskScheduleDto result = new TaskScheduleDto();
        List<TaskScheduleTmItemDto> tms = new ArrayList<>();
        List<TaskScheduleGroupDto> groups = new ArrayList<>();

        //获取指定任务信息
        EhsTaskInfo taskInfo = taskInfoRepository.selectById(taskId);
        if (Objects.isNull(taskInfo)) throw new QCPromptException("指定任务信息不存在");

        //获取指定任务的所有分组
        List<TaskGroupInfoDto> taskGroups = getTaskGroups(taskId);
        if (CollectionUtils.isNotEmpty(taskGroups)) {
            for (TaskGroupInfoDto group : taskGroups) {
                TaskScheduleGroupDto scheduleGroupDto = new TaskScheduleGroupDto();
                scheduleGroupDto.setGroup(group);

                int execcount = 0x0;//实际执行总次数
                int timeoutcount = 0x0;//超时完成总次数
                int execidentifycount = 0x0;//辨识危险源总次数
                int exectroublecount = 0x0;//上报隐患总次数

                //分组执行周期完成情况集合
                List<TaskScheduleGroupItemDto> items = new ArrayList<>();
                //获取指定分组的所有任务项
                List<TaskItemInfoDto> groupItems = taskItemService.getItemsByGroupId(group.getGroupid());
                if (CollectionUtils.isNotEmpty(groupItems)) {
                    for (TaskItemInfoDto groupItem : groupItems) {
                        TaskScheduleTmItemDto tm = new TaskScheduleTmItemDto();
                        tm.setTmstr(groupItem.getPlantmstr());
                        tm.setBegintm(groupItem.getPlanbegintm());
                        tm.setEndtm(groupItem.getPlanendtm());
                        tm.setFrequencytype(groupItem.getPlanfrequencytype());
                        tm.setFrequencycount(groupItem.getPlanfrequencycount());
                        tms.add(tm);

                        TaskScheduleGroupItemDto scheduleGroupItemDto = new TaskScheduleGroupItemDto();
                        scheduleGroupItemDto.setHasfinish(groupItem.isHasfinish());
                        //如果完成时间 > 计划截止时间判定为超时完成；
                        if (StringUtils.isNotBlank(groupItem.getExecendtm()) &&
                                DateUtil.parseDate(groupItem.getExecendtm()).after(DateUtil.parseDate(groupItem.getPlanendtm()))) {
                            scheduleGroupItemDto.setIstimeout(true);
                            timeoutcount += 0x1;
                        } else {
                            scheduleGroupItemDto.setIstimeout(false);
                        }
                        scheduleGroupItemDto.setHasend(groupItem.isHasend());
                        scheduleGroupItemDto.setExeccount(groupItem.getExeccount());
                        scheduleGroupItemDto.setExecidentifycount(groupItem.getExecidentifycount());
                        scheduleGroupItemDto.setExectroublecount(groupItem.getExectroublecount());
                        items.add(scheduleGroupItemDto);

                        execcount += groupItem.getExeccount();
                        execidentifycount += groupItem.getExecidentifycount();
                        exectroublecount += groupItem.getExectroublecount();

                    }
                }
                scheduleGroupDto.setItems(items);

                //分组执行情况汇总
                TaskScheduleGroupSummaryDto summary = new TaskScheduleGroupSummaryDto();
                summary.setPlancount(taskInfo.getPlantotalcount());
                summary.setExeccount(execcount);
                summary.setTimeoutcount(timeoutcount);
                summary.setExecidentifycount(execidentifycount);
                summary.setExectroublecount(exectroublecount);
                scheduleGroupDto.setSummary(summary);

                groups.add(scheduleGroupDto);
            }
        }

        result.setTms(tms.stream().distinct().collect(Collectors.toList()));
        result.setGroups(groups);
        return result;
    }

}
